1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26 package com.sun.java.swing;
27
28 import sun.awt.EventQueueDelegate;
29 import sun.awt.AppContext;
30 import java.util.Collections;
31 import java.util.Map;
32 import java.util.WeakHashMap;
33 import java.util.concurrent.Callable;
34 import java.applet.Applet;
35 import java.awt.AWTEvent;
36 import java.awt.EventQueue;
37 import java.awt.Component;
38 import java.awt.Container;
39 import java.awt.Window;
40 import javax.swing.JComponent;
41 import javax.swing.RepaintManager;
42
43
44
45
46
47
48
49
50
51
52
53
54
55 public class SwingUtilities3 {
56
57
58
59 private static final Object DELEGATE_REPAINT_MANAGER_KEY =
60 new StringBuilder("DelegateRepaintManagerKey");
61
62
63
64
65 public static void setDelegateRepaintManager(JComponent component,
66 RepaintManager repaintManager) {
67
68
69
70 AppContext.getAppContext().put(DELEGATE_REPAINT_MANAGER_KEY,
71 Boolean.TRUE);
72
73 component.putClientProperty(DELEGATE_REPAINT_MANAGER_KEY,
74 repaintManager);
75 }
76
77 private static final Map<Container, Boolean> vsyncedMap =
78 Collections.synchronizedMap(new WeakHashMap<Container, Boolean>());
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93 public static void setVsyncRequested(Container rootContainer,
94 boolean isRequested) {
95 assert (rootContainer instanceof Applet) || (rootContainer instanceof Window);
96 if (isRequested) {
97 vsyncedMap.put(rootContainer, Boolean.TRUE);
98 } else {
99 vsyncedMap.remove(rootContainer);
100 }
101 }
102
103
104
105
106
107
108
109 public static boolean isVsyncRequested(Container rootContainer) {
110 assert (rootContainer instanceof Applet) || (rootContainer instanceof Window);
111 return Boolean.TRUE == vsyncedMap.get(rootContainer);
112 }
113
114
115
116
117 public static RepaintManager getDelegateRepaintManager(Component
118 component) {
119 RepaintManager delegate = null;
120 if (Boolean.TRUE == AppContext.getAppContext().get(
121 DELEGATE_REPAINT_MANAGER_KEY)) {
122 while (delegate == null && component != null) {
123 while (component != null
124 && ! (component instanceof JComponent)) {
125 component = component.getParent();
126 }
127 if (component != null) {
128 delegate = (RepaintManager)
129 ((JComponent) component)
130 .getClientProperty(DELEGATE_REPAINT_MANAGER_KEY);
131 component = component.getParent();
132 }
133
134 }
135 }
136 return delegate;
137 }
138
139
140
141
142
143 public static void setEventQueueDelegate(
144 Map<String, Map<String, Object>> map) {
145 EventQueueDelegate.setDelegate(new EventQueueDelegateFromMap(map));
146 }
147
148 private static class EventQueueDelegateFromMap
149 implements EventQueueDelegate.Delegate {
150 private final AWTEvent[] afterDispatchEventArgument;
151 private final Object[] afterDispatchHandleArgument;
152 private final Callable<Void> afterDispatchCallable;
153
154 private final AWTEvent[] beforeDispatchEventArgument;
155 private final Callable<Object> beforeDispatchCallable;
156
157 private final EventQueue[] getNextEventEventQueueArgument;
158 private final Callable<AWTEvent> getNextEventCallable;
159
160 @SuppressWarnings("unchecked")
161 public EventQueueDelegateFromMap(Map<String, Map<String, Object>> objectMap) {
162 Map<String, Object> methodMap = objectMap.get("afterDispatch");
163 afterDispatchEventArgument = (AWTEvent[]) methodMap.get("event");
164 afterDispatchHandleArgument = (Object[]) methodMap.get("handle");
165 afterDispatchCallable = (Callable<Void>) methodMap.get("method");
166
167 methodMap = objectMap.get("beforeDispatch");
168 beforeDispatchEventArgument = (AWTEvent[]) methodMap.get("event");
169 beforeDispatchCallable = (Callable<Object>) methodMap.get("method");
170
171 methodMap = objectMap.get("getNextEvent");
172 getNextEventEventQueueArgument =
173 (EventQueue[]) methodMap.get("eventQueue");
174 getNextEventCallable = (Callable<AWTEvent>) methodMap.get("method");
175 }
176
177 @Override
178 public void afterDispatch(AWTEvent event, Object handle) throws InterruptedException {
179 afterDispatchEventArgument[0] = event;
180 afterDispatchHandleArgument[0] = handle;
181 try {
182 afterDispatchCallable.call();
183 } catch (InterruptedException e) {
184 throw e;
185 } catch (RuntimeException e) {
186 throw e;
187 } catch (Exception e) {
188 throw new RuntimeException(e);
189 }
190 }
191
192 @Override
193 public Object beforeDispatch(AWTEvent event) throws InterruptedException {
194 beforeDispatchEventArgument[0] = event;
195 try {
196 return beforeDispatchCallable.call();
197 } catch (InterruptedException e) {
198 throw e;
199 } catch (RuntimeException e) {
200 throw e;
201 } catch (Exception e) {
202 throw new RuntimeException(e);
203 }
204 }
205
206 @Override
207 public AWTEvent getNextEvent(EventQueue eventQueue) throws InterruptedException {
208 getNextEventEventQueueArgument[0] = eventQueue;
209 try {
210 return getNextEventCallable.call();
211 } catch (InterruptedException e) {
212 throw e;
213 } catch (RuntimeException e) {
214 throw e;
215 } catch (Exception e) {
216 throw new RuntimeException(e);
217 }
218 }
219 }
220 }